import 'dart:io';
import 'package:flutter/foundation.dart';
import 'package:path/path.dart' as path;

/// 路径工具类，用于处理图片路径的相对路径和绝对路径转换
class PathUtil {
  /// 基础备份目录
  static String? _baseBackupDir;
  
  /// 设置基础备份目录
  static void setBaseBackupDir(String dir) {
    _baseBackupDir = dir;
  }
  
  /// 获取基础备份目录
  static String? getBaseBackupDir() {
    return _baseBackupDir;
  }
  
  /// 将绝对路径转换为相对路径
  /// 
  /// 如果路径是网络URL，则直接返回
  /// 如果路径是本地绝对路径，则转换为相对于备份目录的相对路径
  static String toRelativePath(String? absolutePath) {
    // 如果路径为空，直接返回空字符串
    if (absolutePath == null || absolutePath.isEmpty) {
      return '';
    }
    
    // 如果是网络URL，直接返回
    if (absolutePath.startsWith('http://') || absolutePath.startsWith('https://')) {
      return absolutePath;
    }
    
    // 如果已经是相对路径（不包含盘符或根目录标识），直接返回
    bool isAbsolutePath = absolutePath.startsWith('/') || 
                          RegExp(r'^[A-Za-z]:\\').hasMatch(absolutePath) || 
                          absolutePath.startsWith('c:/') || 
                          absolutePath.startsWith('C:/');
    
    if (!isAbsolutePath) {
      return absolutePath;
    }
    
    try {
      // 标准化路径分隔符
      String normalizedPath = absolutePath.replaceAll('\\', '/');
      
      // 如果没有设置基础备份目录，则使用文件名作为相对路径
      if (_baseBackupDir == null) {
        return path.basename(normalizedPath);
      }
      
      // 标准化基础备份目录
      String normalizedBaseDir = _baseBackupDir!.replaceAll('\\', '/');
      
      // 如果路径包含基础备份目录，则提取相对部分
      if (normalizedPath.startsWith(normalizedBaseDir)) {
        // 去除基础目录部分，保留相对路径
        String relativePath = normalizedPath.substring(normalizedBaseDir.length);
        // 确保相对路径不以斜杠开头
        if (relativePath.startsWith('/')) {
          relativePath = relativePath.substring(1);
        }
        return relativePath;
      }
      
      // 如果不在基础目录下，则使用文件名作为相对路径
      return path.basename(normalizedPath);
    } catch (e) {
      print('转换相对路径时出错: $e');
      // 出错时返回文件名
      return path.basename(absolutePath);
    }
  }
  
  /// 将相对路径转换为绝对路径
  /// 
  /// 如果路径是网络URL，则直接返回
  /// 如果路径是相对路径，则转换为基于备份目录的绝对路径
  static String toAbsolutePath(String? relativePath) {
    // 如果路径为空，直接返回空字符串
    if (relativePath == null || relativePath.isEmpty) {
      return '';
    }
    
    // 如果是网络URL，直接返回
    if (relativePath.startsWith('http://') || relativePath.startsWith('https://')) {
      return relativePath;
    }
    
    // 如果已经是绝对路径，直接返回
    bool isAbsolutePath = relativePath.startsWith('/') || 
                          RegExp(r'^[A-Za-z]:\\').hasMatch(relativePath) || 
                          relativePath.startsWith('c:/') || 
                          relativePath.startsWith('C:/');
    
    if (isAbsolutePath) {
      return relativePath;
    }
    
    // 如果没有设置基础备份目录，则无法转换为绝对路径，返回原路径
    if (_baseBackupDir == null) {
      return relativePath;
    }
    
    try {
      // 标准化基础备份目录
      String normalizedBaseDir = _baseBackupDir!.replaceAll('\\', '/');
      // 确保基础目录以斜杠结尾
      if (!normalizedBaseDir.endsWith('/')) {
        normalizedBaseDir += '/';
      }
      
      // 组合路径
      String absolutePath = normalizedBaseDir + relativePath;
      
      // 根据平台返回正确的路径格式
      if (Platform.isWindows) {
        return absolutePath.replaceAll('/', '\\');
      } else {
        return absolutePath;
      }
    } catch (e) {
      print('转换绝对路径时出错: $e');
      // 出错时返回原路径
      return relativePath;
    }
  }
  
  /// 检查文件是否存在
  static Future<bool> fileExists(String filePath) async {
    if (filePath.isEmpty) {
      return false;
    }
    
    if (filePath.startsWith('http://') || filePath.startsWith('https://')) {
      // 网络文件无法直接检查是否存在
      return true;
    }
    
    try {
      return await File(filePath).exists();
    } catch (e) {
      print('检查文件是否存在时出错: $e');
      return false;
    }
  }
}